/**
内部类就是在一个类的内部定义类
	作用就是解决java 多继承的问题

1.成员内部类语法如下:
class Outer{
	class Inner{}
}

编译上述代码会产生两个文件
Outer.class   Outer$Inner.class

2. 方法内部类
内部类可以作为一个类的成员外，还可以把类放在方法内定义。
语法如下:
class Outer{
	public void doSomething(){
		class Inner{
			public void print(){
			}
		}
	}
}

3.静态内部类
在一个类内部定义一个静态内部类:
静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时，也能够访问它。静态嵌套类
仅能访问外部类的静态成员和方法。
语法如下:
class Outer{
	static class Inner{}
}
class Test{
	public static void main(String[] args){
		Outer.Inner n=new Outer.Inner();
	}
}


内部类
	1.成员内部类:直接在类中定义的类
	2.方法内部类:在一个类中的方法内定义一个类
		(1)方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化
		(2)方法内部类对象不能使用该内部类所在方法的非final局部变量.
	3.静态内部类,在类中定义一个静态修饰的内部类
		静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它.
		静态嵌套类仅能访问外部类的静态成员和方法
	4.匿名内部类就是没有名字的内部类。
		匿名内部类的三种情况
			(1)继承式的匿名内部类
			(2)接口式的匿名内部类
			(3)参数式的匿名内部类

匿名内部类规则
1.不能有构造方法，只能有一个实例
2.不能定义任何静态成员，静态方法  (不改变)
3.不能是public,protected,private,static
4.一定是在new的后面，用其隐含实现一个接口或实现一个类
5.匿名内部类为局部的，所以局部内部类的所有限制对其生效

成员
成员内部类
静态内部类
局部
方法内部类
匿名内部类

依赖外部对象:成员，方法，匿名
不依赖:静态  项目优先考虑
 */


/*
package com.leo.第五章_面向对象下;

public class U5_L18_内部类语法 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//下面3行是内部类的对象建立方式 先有外部内的对象  用外部内的对象的.new成员属性 创建新的内部类对象
		//创建外部类对象是怕找不到外部类 用外部类.new 让内外类产生依赖
		//一般不这样用，直接在内部私有化内部类
		//Outer outer=new Outer();
		//Outer.Inner inner=outer.new Inner();
		//inner.print();
		
		//内部类隐式调用对象
		Outer outer=new Outer();
		outer.getobj();
		
		//方法内部类对象的调用方式
		Outer_method outer_method=new Outer_method();
		outer_method.inner_method();
		
//		//静态内部类对象的调用方法
		//外部类消失了，内部类还能正常运行
		Outer_static_method.Inner_static_method inner_static_method=new Outer_static_method.Inner_static_method();
		inner_static_method.print();
		
		//通过外部类对象实现	调用继承式匿名内部类
		Outer_abstract outer_abstract=new Outer_abstract();
		outer_abstract.getinner_obj();
		
		//通过外部类对象内部实现 条用继承式匿名内部类
		Outer_abstract.Inner_abstract in=outer_abstract.new Inner_abstract();
		in.print_abstract();
		
		//通过外部类对象内部实现 调用接口式内部类
		Outer_interface outer_interface=new Outer_interface();
		outer_interface.getinner_obj();
		
		//
		Outer_Pp outer_pp=new Outer_Pp();
		Outer_Pp.Inner_Pp inner_pp=outer_pp.new Inner_Pp();		
		inner_pp.print_inner_pp(new Pp() {public void pp() {System.out.println("6.参数式匿名内部类实现！");}});
	}

}

//1.这个是成员外 内部类
class Outer{
	public void getobj() {
		Inner inner=new Inner();
		inner.print();
	}
	//这个是成员内部类
	private class Inner{
		public void print() {
			System.out.println("1.这个是成员内部类。");
		}
	}
}

//2.这个是方法外 内部类
class Outer_method{
	public void inner_method() {
		class Inner_method{
			//方法 内部类都是常量  原因代码块类的代码执行完就会消失，但是对象不会消失，可属性用不了就会异常
			final String name="方法内部类无法修改内部类里面的成员属性，都是默认+finnal的常量";
			public void print() {
				System.out.println("2.这个是方法内部类和其final String name：\n  "+name);
			}
		}
		//要写在方法内部类下面
		Inner_method inner_method=new Inner_method();
		inner_method.print();
	}	
}

//3.静态 内部类
class Outer_static_method{
	static class Inner_static_method{
		public void print() {
			System.out.println("3.这是静态内部类.");
		}
	}
}

//4.继承式匿名内部类
class Outer_abstract{
	public void getinner_obj() {
		Inner_abstract inner_abstract=new Inner_abstract();
		inner_abstract.print_abstract();
	}
	
	class Inner_abstract{
		public void print_abstract() {
			//把代码块写进了对象开辟的堆空间 
			Cat cat=new Cat() {
				public void eat() {
					System.out.println("4.继承式匿名内部类的实现！");
				}
			};
			cat.eat();
		}
	}
}

//5.接口式匿名内部类
class Outer_interface{
	public void getinner_obj() {
		Inner_interface in=new Inner_interface();
		in.print_inner_interface();
	}
	
	class Inner_interface{
		public void print_inner_interface() {
			Dog dog=new Dog() {
				public void eat(){
					System.out.println("5.接口式匿名内部类实现！");
				}
			};
			dog.eat();
		}
	}
}

abstract class Cat{
	public abstract void eat();
}

interface Dog{
	public void eat();
}

//6.参数式匿名内部类
class Outer_Pp{
	class Inner_Pp{
		public void print_inner_pp(Pp pp) {
			pp.pp();
		}
	}
}


interface Pp{
	public void pp();
}
*/


